// fftest2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
extern "C"
{


#include "avcodec.h"
#include "avformat.h"
	};



#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif




/* 5 seconds stream duration */
#define STREAM_DURATION   12
#define STREAM_FRAME_RATE 25 /* 25 images/s */
#define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
#define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */

//static int sws_flags = SWS_BICUBIC;

/**************************************************************/
/* audio output */
CodecID vid = CODEC_ID_H264;
CodecID aid = CODEC_ID_AAC;
char* myfile = "c:\\ff2_264AAC.mp4";

float t, tincr, tincr2;
int16_t *samples;
uint8_t *audio_outbuf;
int audio_outbuf_size;
int audio_input_frame_size;


/*
* add an audio output stream
*/
static AVStream *add_audio_stream(AVFormatContext *oc, int codec_id)
{
	AVCodecContext *c;
	AVStream *st;

	st = av_new_stream(oc, 1);
	if (!st) {
		fprintf(stderr, "Could not alloc stream\n");
		
	}

	c = st->codec;
	c->codec_id = (CodecID)aid;
	c->codec_type = CODEC_TYPE_AUDIO;

	/* put sample parameters */
	c->bit_rate = 128000;
	c->sample_rate = 48000;
	c->channels = 2;
	AVRational av = {1, c->sample_rate};
	c->time_base = av;
	
	if(oc->oformat->flags && AVFMT_GLOBALHEADER){
		c->flags |= CODEC_FLAG_GLOBAL_HEADER;		
	}
	return st;
}



static void open_audio(AVFormatContext *oc, AVStream *st)
{
	AVCodecContext *c;
	AVCodec *codec;

	c = st->codec;
	/* find the audio encoder */
	codec = avcodec_find_encoder(c->codec_id);
	if (!codec) {
		fprintf(stderr, "codec not found\n");
		
	}

	/* open it */
	if (avcodec_open(c, codec) < 0) {
		fprintf(stderr, "could not open codec\n");
		
	}

	/* init signal generator */
	t = 0;
	tincr = 2 * M_PI * 110.0 / c->sample_rate;
	/* increment frequency by 110 Hz per second */
	tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;

	audio_outbuf_size = 10000;
	audio_outbuf = (uint8_t*)av_malloc(audio_outbuf_size);

	/* ugly hack for PCM codecs (will be removed ASAP with new PCM
	support to compute the input frame size in samples */
	if (c->frame_size <= 1) {
		audio_input_frame_size = audio_outbuf_size / c->channels;
		switch(st->codec->codec_id) {
		case CODEC_ID_PCM_S16LE:
		case CODEC_ID_PCM_S16BE:
		case CODEC_ID_PCM_U16LE:
		case CODEC_ID_PCM_U16BE:
			audio_input_frame_size >>= 1;
			break;
		default:
			break;
		}
	} else {
		audio_input_frame_size = c->frame_size;
	}
	samples = (int16_t*)av_malloc(audio_input_frame_size * 2 * c->channels);
}


static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
{
	int j, i, v;
	int16_t *q;

	q = samples;
	for(j=0;j<frame_size;j++) {
		v = (int)(sin(t) * 10000);
		for(i = 0; i < nb_channels; i++)
			*q++ = v;
		t += tincr;
		tincr += tincr2;
	}
}



static void write_audio_frame(AVFormatContext *oc, AVStream *st)
{
	AVCodecContext *c;
	AVPacket pkt;
	av_init_packet(&pkt);

	c = st->codec;

	get_audio_frame(samples, audio_input_frame_size, c->channels);
	int ret = avcodec_encode_audio(c, audio_outbuf, audio_outbuf_size, samples);
	if(ret == 0) return;

	pkt.size= ret;
	pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
	pkt.flags |= PKT_FLAG_KEY;
	pkt.stream_index= st->index;
	pkt.data= audio_outbuf;

	/* write the compressed frame in the media file */
	if (av_write_frame(oc, &pkt) != 0) {
		fprintf(stderr, "Error while writing audio frame\n");
		
	}
}

static void close_audio(AVFormatContext *oc, AVStream *st)
{
	avcodec_close(st->codec);
	av_free(samples);
	av_free(audio_outbuf);
}

AVFrame *picture, *tmp_picture;
uint8_t *video_outbuf;
int frame_count, video_outbuf_size;


/* add a video output stream */
static AVStream *add_video_stream(AVFormatContext *oc, int codec_id)
{
	AVCodecContext *c;
	AVStream *st;

	st = av_new_stream(oc, 0);
	if (!st) {
		fprintf(stderr, "Could not alloc stream\n");		
	}

	c = st->codec;
	c->codec_id = (CodecID)vid;
	c->codec_type = CODEC_TYPE_VIDEO;

	/* put sample parameters */
	c->bit_rate = 400000;	
	c->width = 352;
	c->height = 288;	
	c->time_base.den = 25;
	c->time_base.num = 1;
	//c->gop_size = 250; 
	c->pix_fmt = (PixelFormat)0;
	//c->level = 13;
	//c->bit_rate = 768000;
	//c->rc_max_rate = 768000;
	//c->rc_buffer_size = 2000000;
	if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
		/* just for testing, we also add B frames */
		c->max_b_frames = 2;
	}
	if (c->codec_id == CODEC_ID_MPEG1VIDEO){
		/* Needed to avoid using macroblocks in which some coeffs overflow.
		This does not happen with normal video, it just happens here as
		the motion of the chroma plane does not match the luma plane. */
		c->mb_decision=2;
	}
	// some formats want stream headers to be separate
	
	if(oc->oformat->flags && AVFMT_GLOBALHEADER){
		c->flags |= CODEC_FLAG_GLOBAL_HEADER;		
	}
	//if(!strcmp(oc->oformat->name, "mp4") || !strcmp(oc->oformat->name, "mov") || !strcmp(oc->oformat->name, "3gp"))
		

	return st;
}


static AVFrame *alloc_picture(int pix_fmt, int width, int height)
{
	AVFrame *picture;
	uint8_t *picture_buf;
	int size;

	picture = avcodec_alloc_frame();
	if (!picture)
		return NULL;
	size = avpicture_get_size(pix_fmt, width, height);
	picture_buf = (uint8_t*)av_malloc(size);
	if (!picture_buf) {
		av_free(picture);
		return NULL;
	}
	avpicture_fill((AVPicture *)picture, picture_buf,
		pix_fmt, width, height);
	return picture;
}

static void open_video(AVFormatContext *oc, AVStream *st)
{
	AVCodec *codec;
	AVCodecContext *c;
	c = st->codec;

	/* find the video encoder */
	codec = avcodec_find_encoder(c->codec_id);
	if (!codec) {
		fprintf(stderr, "codec not found\n");	
	}

	/* open the codec */
	if (avcodec_open(c, codec) < 0) {
		fprintf(stderr, "could not open codec\n");		
	}

	video_outbuf = NULL;
	if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
		video_outbuf_size = 200000;
		video_outbuf = (uint8_t*)av_malloc(video_outbuf_size);
	}

	/* allocate the encoded raw picture */
	picture = alloc_picture(c->pix_fmt, c->width, c->height);
	if (!picture) {
		fprintf(stderr, "Could not allocate picture\n");		
	}

	/* if the output format is not YUV420P, then a temporary YUV420P
	picture is needed too. It is then converted to the required
	output format */
	tmp_picture = NULL;
	if (c->pix_fmt != 0) {
		tmp_picture = alloc_picture(0, c->width, c->height);
		if (!tmp_picture) {
			fprintf(stderr, "Could not allocate temporary picture\n");
			
		}
	}
}


/* prepare a dummy image */
static void fill_yuv_image(AVFrame *pict, int frame_index, int width, int height)
{
	int x, y, i;

	i = frame_index;

	/* Y */
	for(y=0;y<height;y++) {
		for(x=0;x<width;x++) {
			pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
		}
	}

	/* Cb and Cr */
	for(y=0;y<height/2;y++) {
		for(x=0;x<width/2;x++) {
			pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
			pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
		}
	}
}

static void write_video_frame(AVFormatContext *oc, AVStream *st)
{
	int out_size, ret;
	AVCodecContext *c;
	//static struct SwsContext *img_convert_ctx;

	c = st->codec;
	
	fill_yuv_image(picture, frame_count, c->width, c->height);


	if (oc->oformat->flags & AVFMT_RAWPICTURE) {
		/* raw video case. The API will change slightly in the near
		futur for that */
		AVPacket pkt;
		av_init_packet(&pkt);

		pkt.flags |= PKT_FLAG_KEY;
		pkt.stream_index= st->index;
		pkt.data= (uint8_t *)picture;
		pkt.size= sizeof(AVPicture);

		ret = av_write_frame(oc, &pkt);
	} else {
		/* encode the image */
		out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
		/* if zero size, it means the image was buffered */
		if (out_size > 0) {
			AVPacket pkt;
			av_init_packet(&pkt);

			pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
			//pkt.pts = 0;
			if(c->coded_frame->key_frame)
				pkt.flags |= PKT_FLAG_KEY;
			pkt.stream_index= st->index;
			pkt.data= video_outbuf;
			pkt.size= out_size;

			/* write the compressed frame in the media file */
			ret = av_write_frame(oc, &pkt);
		} else {
			ret = 0;
		}
	}
	if (ret != 0) {
		fprintf(stderr, "Error while writing video frame\n");
		
	}
	frame_count++;
}

static void close_video(AVFormatContext *oc, AVStream *st)
{
	avcodec_close(st->codec);
	av_free(picture->data[0]);
	av_free(picture);
	if (tmp_picture) {
		av_free(tmp_picture->data[0]);
		av_free(tmp_picture);
	}
	av_free(video_outbuf);
}



#if 0
int _tmain(int argc, _TCHAR* argv[])
{
	char* p = __TIME__;
	const char *filename = myfile;
	AVOutputFormat *fmt;
	AVFormatContext *oc;
	AVStream *audio_st, *video_st;
	double audio_pts, video_pts;
	int i;

	/* initialize libavcodec, and register all codecs and formats */
 	av_register_all();

	fmt = guess_format(NULL, filename, NULL);
	if (!fmt) {
		printf("Could not deduce output format from file extension: using MPEG.\n");
		fmt = guess_format("mpeg", NULL, NULL);
	}
	if (!fmt) {
		fprintf(stderr, "Could not find suitable output format\n");
		
	}

	/* allocate the output media context */
	oc = av_alloc_format_context();
	if (!oc) {
		fprintf(stderr, "Memory error\n");
		
	}
	oc->oformat = fmt;
	_snprintf(oc->filename, sizeof(oc->filename), "%s", filename);

	video_st = NULL;
	audio_st = NULL;
	if (fmt->video_codec != CODEC_ID_NONE) {
		video_st = add_video_stream(oc, vid);
	}
	if (fmt->audio_codec != CODEC_ID_NONE) {
		audio_st = add_audio_stream(oc, aid);
	}

	/* set the output parameters (must be done even if no
	parameters). */
	if (av_set_parameters(oc, NULL) < 0) {
		fprintf(stderr, "Invalid output format parameters\n");
		
	}

	oc->preload= (int)(0.5*AV_TIME_BASE);
	oc->max_delay= (int)(0.7*AV_TIME_BASE);
	oc->loop_output = -1;

	//dump_format(oc, 0, filename, 1);

	/* now that all the parameters are set, we can open the audio and
	video codecs and allocate the necessary encode buffers */
	if (video_st)
		open_video(oc, video_st);
	if (audio_st)
		open_audio(oc, audio_st);

	/* open the output file, if needed */
	if (!(fmt->flags & AVFMT_NOFILE)) {
		if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
			fprintf(stderr, "Could not open '%s'\n", filename);
			
		}
	}

	/* write the stream header, if any */
	av_write_header(oc);

	for(;;) {
		/* compute current audio and video time */
		if (audio_st)
			audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
		else
			audio_pts = 0.0;

		if (video_st)
			video_pts = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
		else
			video_pts = 0.0;

		if ((!audio_st || audio_pts >= STREAM_DURATION) &&
			(!video_st || video_pts >= STREAM_DURATION))
			break;



		if ( audio_pts <= video_pts) {
			
		
			{write_audio_frame(oc, audio_st);}
			
		} else {
			write_video_frame(oc, video_st);
			
		}

		///* write interleaved audio and video frames */
		//if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
		//	
		//	for(int i = 0; i < 4; i++)
		//	{write_audio_frame(oc, audio_st);}
		//	
		//} else {
		//	write_video_frame(oc, video_st);
		//	
		//}
	}

	/* close each codec */
	if (video_st)
		close_video(oc, video_st);
	if (audio_st)
		close_audio(oc, audio_st);

	/* write the trailer, if any */
	av_write_trailer(oc);

	/* free the streams */
	for(i = 0; i < oc->nb_streams; i++) {
		av_freep(&oc->streams[i]->codec);
		av_freep(&oc->streams[i]);
	}

	if (!(fmt->flags & AVFMT_NOFILE)) {
		/* close the output file */
		url_fclose(&oc->pb);
	}

	/* free the stream */
	av_free(oc);
	MessageBox(0, _T("OK"), _T(""), 0);
	return 0;
}

#else
int _tmain(int argc, _TCHAR* argv[])
{
	AVFormatContext *ic;
	AVFormatParameters params, *ap = &params;
	int err, i, ret, rfps, rfps_base;
	int64_t timestamp;
	char* filename = "i:\\video\\chicken.wmv";
	AVInputFormat * file_iformat;


	ic = av_alloc_format_context();

	memset(ap, 0, sizeof(*ap));

	err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
	if (err < 0) {
		
	}

	/* If not enough info to get the stream parameters, we decode the
	first frames to get it. (used in mpeg case for example) */
	ret = av_find_stream_info(ic);
}
#endif